home *** CD-ROM | disk | FTP | other *** search
/ Multimedia Producer's Bible / Multimedia Producer's Bible.iso / mac / mTropolis / mTropolis Sampler Files / mFactory Object Model Examples / Source / SimpMsgr / SimpMsgr.c next >
Encoding:
C/C++ Source or Header  |  1996-01-04  |  6.0 KB  |  259 lines  |  [TEXT/MMCC]
  1. /*    SimpMsgr.c
  2. **
  3. **    Copyright 1995, mFactory, Inc.
  4. **    All rights reserved.
  5. */
  6.  
  7. #include "SimpMsgr.h"
  8.  
  9. #define kActivatePopup        6        // DITL indices
  10. #define kSendPopup            9
  11.  
  12.  
  13. /*    Initial entry point
  14. */
  15.  
  16. MCompMainFuncDcl MCompMainName(MInitInfo *initInfo)
  17. {
  18.     MDefineComponent(SimpMsgrComp, kMCanDragOff);
  19.     MInheritClass(MComponent, kMCompNumProcs, kMBaseCompSlot);
  20.  
  21.     // MComponent methods we must override
  22.  
  23.     MDefineMethod(kSimpMsgrSlot, kMBaseCompSlot, kMCompConstructor, MCompConstructor);
  24.     MDefineMethod(kSimpMsgrSlot, kMBaseCompSlot, kMCompCopy, MCompCopy);
  25.     MDefineMethod(kSimpMsgrSlot, kMBaseCompSlot, kMCompCopyConstructor, MCompCopyConstructor);
  26.     MDefineMethod(kSimpMsgrSlot, kMBaseCompSlot, kMCompDestructor, MCompDestructor);
  27.  
  28.     // MComponent methods we choose to override
  29.  
  30.     MDefineMethod(kSimpMsgrSlot, kMBaseCompSlot, kMCompEditorOpen, MCompEditorOpen);
  31.     MDefineMethod(kSimpMsgrSlot, kMBaseCompSlot, kMCompEditorAccept, MCompEditorAccept);
  32.  
  33.     MDefineMethod(kSimpMsgrSlot, kMBaseCompSlot, kMCompGetSaveInfo, MCompGetSaveInfo);
  34.     MDefineMethod(kSimpMsgrSlot, kMBaseCompSlot, kMCompSaveComponent, MCompSaveComponent);
  35.     MDefineMethod(kSimpMsgrSlot, kMBaseCompSlot, kMCompRestoreComponent, MCompRestoreComponent);
  36.  
  37.     MDefineMethod(kSimpMsgrSlot, kMBaseCompSlot, kMCompEnabled, MCompEnabled);
  38.     MDefineMethod(kSimpMsgrSlot, kMBaseCompSlot, kMCompDisabled, MCompDisabled);
  39.     
  40.     MDefineMethod(kSimpMsgrSlot, kMBaseCompSlot, kMCompProcessMessage, MCompProcessMessage);
  41.  
  42.     MDefineMethod(kSimpMsgrSlot, kMBaseCompSlot, kMCompGetAttribute, MCompGetAttribute);
  43.  
  44.     MDefineMethod(kSimpMsgrSlot, kMBaseCompSlot, kMCompAdaptIDs, MCompAdaptIDs);
  45.  
  46.     MConnectCommonServices(initInfo);
  47.  
  48.     MEndComponentDef;
  49. }
  50.  
  51.  
  52. /*    Initialize component
  53. */
  54.  
  55. static MErr MCompConstructor(SimpMsgrComp *self, MObjectRef *mRef)
  56. {
  57.     MInitEvent(self->f_activateEvent, kMMouseUp, 0);
  58.     MInitEvent(self->f_sendEvent, kMNone, 0);
  59.     return kMNoCompErr;
  60. }
  61.  
  62.  
  63. /*    Copy component data
  64. */
  65.  
  66. static MErr MCompCopy(SimpMsgrComp *self, SimpMsgrComp *previousSelf)
  67. {
  68.     MCopyEvent(self->f_activateEvent, previousSelf->f_activateEvent);
  69.     MCopyEvent(self->f_sendEvent, previousSelf->f_sendEvent);
  70.     return kMNoCompErr;
  71. }
  72.  
  73.  
  74. /*    Copy component
  75. */
  76.  
  77. static MErr MCompCopyConstructor(SimpMsgrComp *self, SimpMsgrComp *previousSelf, MObjectRef *mRef)
  78. {
  79.     MCompConstructor(self, mRef);
  80.     return MCompCopy(self, previousSelf);
  81. }
  82.  
  83.  
  84. /*    Dispose component
  85. */
  86.  
  87. static MErr MCompDestructor(SimpMsgrComp *self)
  88. {
  89.     MDisposeEvent(self->f_activateEvent);
  90.     MDisposeEvent(self->f_sendEvent);
  91.     return kMNoCompErr;
  92. }
  93.  
  94.  
  95. /*    Open component dialog
  96. */
  97.  
  98. static MErr MCompEditorOpen(SimpMsgrComp *self, void *editor, short editorType)
  99. {
  100.     if ( editorType == kMDialogEditorType ) {
  101.         MSetEditorItem(editor, kActivatePopup, (MDataType *) &self->f_activateEvent);
  102.         MSetEditorItem(editor, kSendPopup, (MDataType *) &self->f_sendEvent);
  103.         return kMNoCompErr;
  104.     }
  105.     else
  106.         return kMUnableToComplyCompErr;
  107. }
  108.  
  109.  
  110. /*    Close component dialog
  111. */
  112.  
  113. static MErr MCompEditorAccept(SimpMsgrComp *self, void *editor)
  114. {
  115.     MGetEditorItem(editor, kActivatePopup, (MDataType *) &self->f_activateEvent);
  116.     MGetEditorItem(editor, kSendPopup, (MDataType *) &self->f_sendEvent);
  117.     return kMNoCompErr;
  118. }
  119.  
  120.  
  121. /*    Provide save information
  122. */
  123.  
  124. static MErr MCompGetSaveInfo(SimpMsgrComp *self, MFileIOServ *file, long saveInfo, short *rev, long *len)
  125. {
  126.     long    valueSize;
  127.  
  128.     MSizeOfValue(file, &self->f_activateEvent, &valueSize);
  129.     *len = valueSize;
  130.     MSizeOfValue(file, &self->f_sendEvent, &valueSize);
  131.     *len += valueSize;
  132.  
  133.     *rev = kSimpMsgrRev;
  134.     return kMNoCompErr;
  135. }
  136.  
  137.  
  138. /*    Save component
  139. */
  140.  
  141. static MErr MCompSaveComponent(SimpMsgrComp *self, MFileIOServ *file, long saveInfo)
  142. {
  143.     MWriteValue(file, &self->f_activateEvent);
  144.     MWriteValue(file, &self->f_sendEvent);
  145.     return kMNoCompErr;
  146. }
  147.  
  148.  
  149. /*    Restore component
  150. */
  151.  
  152. static MErr MCompRestoreComponent(SimpMsgrComp *self, MFileIOServ *file, long saveInfo, short rev)
  153. {
  154.     if ( rev == kSimpMsgrRev ) {
  155.         MReadValue(file, &self->f_activateEvent);
  156.         MReadValue(file, &self->f_sendEvent);
  157.         return kMNoCompErr;
  158.     }
  159.     else
  160.         return kMUnableToComplyCompErr;
  161. }
  162.  
  163.  
  164. /*    Component enabled (runtime)
  165. */
  166.  
  167. static MErr MCompEnabled(SimpMsgrComp *self)
  168. {
  169.     MRegisterMouseFeedback(self, &self->f_activateEvent);
  170.     return kMNoCompErr;
  171. }
  172.  
  173.  
  174. /*    Component disabled (runtime)
  175. */
  176.  
  177. static MErr MCompDisabled(SimpMsgrComp *self)
  178. {
  179.     MDeregisterMouseFeedback(self, &self->f_activateEvent);
  180.     return kMNoCompErr;
  181. }
  182.  
  183.  
  184. /*    Get component attribute
  185. */
  186.  
  187. static MErr MCompGetAttribute(SimpMsgrComp *self, MomID attribName, MDataType *selector, MDataType *dataValue)
  188. {
  189.     if ( MCmpMomID(attribName, kMEventsAttrib) && selector ) 
  190.     {
  191.         if ( selector->f_type.f_type == kMInteger ) 
  192.         {
  193.             switch (selector->f_integer.f_value & ~kMEventMask) 
  194.             {
  195.                 case kMEventExecute: 
  196.                     if ( (selector->f_integer.f_value & kMEventMask) == 1 ) {
  197.                         MCopyEvent(dataValue->f_event, self->f_activateEvent);
  198.                         return kMNoCompErr;
  199.                     }
  200.                     else
  201.                         return kMUnableToComplyCompErr;
  202.                         
  203.                 case kMEventSend: 
  204.                     if ( (selector->f_integer.f_value & kMEventMask) == 1 ) {
  205.                         MCopyEvent(dataValue->f_event, self->f_sendEvent);
  206.                         return kMNoCompErr;
  207.                     }
  208.                     else
  209.                         return kMUnableToComplyCompErr;
  210.                         
  211.                 default :
  212.                     return kMUnableToComplyCompErr;
  213.             }
  214.         }
  215.     }
  216.     else
  217.         return kMUnableToComplyCompErr;
  218. }
  219.  
  220.  
  221. /*    Process incoming message
  222. */
  223.  
  224. static MErr MCompProcessMessage(SimpMsgrComp *self, MMessagePtr message)
  225. {
  226.     if ( MDetectMessage(message, self->f_activateEvent) ) {
  227.         MErr        ret;
  228.         MMessage    m;
  229.         MObjectRef    *element = nil;
  230.         MTargetType    target;
  231.         
  232.         // get my element
  233.         MGetElement(&element);
  234.         if ( (ret = MError()) != kMNoCompErr )
  235.             return ret;
  236.             
  237.         if ( !element )
  238.             return kMUnableToComplyCompErr;
  239.             
  240.         // set up message structure and send it
  241.         MInitObjectPtr(target.f_object, (MObjectRef)element);
  242.         MInitSimpleMessage(self, &target, &self->f_sendEvent, &m);
  243.         MSendMessage(&m);
  244.         return MError();
  245.     }
  246.     else
  247.         return kMUnableToComplyCompErr;
  248. }
  249.  
  250.  
  251. /*    Adjust project-specific IDs
  252. */
  253.  
  254. static MErr MCompAdaptIDs(SimpMsgrComp *self, MObjectPtr *sourceStore, MObjectPtr *targetStore)
  255. {
  256.     MTranslateID(kMTranslateEventID, sourceStore, targetStore, (MDataType *) &self->f_activateEvent);
  257.     return kMNoCompErr;
  258. }
  259.